UTILS.c

Go to the documentation of this file.

#include "derivative.h"
#include "utils.h"
#include <limits.h>
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
const uint8_t cau8OddParityTable[] = 
{
  /* This table gives the opposite of the calculated parity - it's what      */
  /* must be added in order to give the correct parity bit.                  */
  /* 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 0A, 0B, 0C, 0D, 0E, 0F */
     0u, 1u, 1u, 0u, 1u, 0u, 0u, 1u, 1u, 0u, 0u, 1u, 0u, 1u, 1u, 0u
    /* 1u, 0u, 0u, 1u, 0u, 1u, 1u, 0u, 0u, 1u, 1u, 0u, 1u, 0u, 0u, 1u*/
};
 /*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u8fnCheckOddParity
 ******************************************************************************
 */
uint8_t u8fnCheckOddParity(uint8_t u8Byte, uint8_t u8ParityPosition)
{
  /* LocalVariables */
  uint8_t u8ParityLow;
  uint8_t u8ParityHigh;
  uint8_t u8Parity;
  
  /* Calculate parity for each nibble in the byte */
  u8ParityHigh = cau8OddParityTable[u8Byte >> BITS_IN_NIBBLE];
  u8ParityLow  = cau8OddParityTable[u8Byte & 0x0Fu];
  
  /* Combine both calculations using XOR: */
  /* Even and even = Even                 */
  /* Odd and odd   = Even                 */
  /* Even and odd  = Odd                  */
  /* Odd and even  = Odd                  */
  u8Parity = (u8ParityHigh ^ u8ParityLow);
  
  /* If u8Parity is cleared, this means we currently hold even parity. */
  if(CLEAR == u8Parity)
  {
    /* If a bit position is set for it, return u8Byte with its value */
    if(CLEAR != u8ParityPosition)
    {
      u8Parity = (u8Byte | u8ParityPosition);
    }
    else
    {
      /* Make u8Parity 1 to signal we need to add one */
      u8Parity = TRUE;
    }
  }
  else
  {
    /* Parity bit is set, meaning the byte is already odd parity */
    if(CLEAR != u8ParityPosition)
    {
      /* Output the message without the parity bit set */
      u8Parity = u8Byte;
    }
    else
    {
      /* Make u8Parity 0 to signal we don't need to add anything */
      u8Parity = CLEAR;
    }
  }
  
  return(u8Parity);
}
/*
 ******************************************************************************
 * u16fnCheckOddParity
 ******************************************************************************
 */
uint16_t u16fnCheckOddParity(uint16_t u16Word, uint16_t u16ParityPosition)
{
  /* LocalVariables */
  uint8_t  u8ParityLow;
  uint8_t  u8ParityHigh;
  uint16_t u16Parity;
  
  /* Calculate parity for each byte in the word - the result is what we need */
  /* to add to the word in order to make it odd parity.                      */
  u8ParityHigh = u8fnCheckOddParity((uint8_t)(u16Word >> BITS_IN_BYTE), CLEAR);
  u8ParityLow  = u8fnCheckOddParity((uint8_t)u16Word, CLEAR);
  
  /* Combine both calculations with XNOR                               */
  /* Parity bit needed + Parity bit needed = Parity bit needed         */
  /* Parity bit needed + Parity bit not needed = Parity bit not needed */
  /* Parity bit not needed + Parity bit needed = Parity bit not needed */
  /* Parity bit not needed + Parity bit not needed = Parity bit needed */
  
  u16Parity = !(u8ParityHigh ^ u8ParityLow);
  
  
  /* If a bit position is set for it, return u16Word with its value */
  if(CLEAR != u16ParityPosition)
  {
    if(CLEAR != u16Parity)
    {
      u16Parity = (u16Word | u16ParityPosition);
    }
    else
    {
      u16Parity = u16Word;
    }
  }
  else
  {
    /* Just Output u16Parity */
  }
  
  return(u16Parity);
}
/*
 ******************************************************************************
 * u32fnCheckOddParity
 ******************************************************************************
 */
uint32_t u32fnCheckOddParity(uint32_t u32Word, uint32_t u32ParityPosition)
{
  /* LocalVariables */
  uint16_t  u16ParityLow;
  uint16_t  u16ParityHigh;
  uint32_t  u32Parity;
  
  /* Calculate parity for each byte in the word - the result is what we need */
  /* to add to the word in order to make it odd parity.                      */
  u16ParityHigh = u16fnCheckOddParity((uint16_t)(u32Word >> BITS_IN_16), CLEAR);
  u16ParityLow  = u16fnCheckOddParity((uint16_t)u32Word, CLEAR);
  
  /* Combine both calculations with XNOR                               */
  /* Parity bit needed + Parity bit needed = Parity bit needed         */
  /* Parity bit needed + Parity bit not needed = Parity bit not needed */
  /* Parity bit not needed + Parity bit needed = Parity bit not needed */
  /* Parity bit not needed + Parity bit not needed = Parity bit needed */
  
  u32Parity = !(u16ParityHigh ^ u16ParityLow);
  
  
  /* If a bit position is set for it, return u32Word with its value */
  if(CLEAR != u32ParityPosition)
  {
    if(CLEAR != u32Parity)
    {
      u32Parity = (u32Word | u32ParityPosition);
    }
    else
    {
      u32Parity = u32Word;
    }
  }
  else
  {
    /* Just Output u32Parity */
  }
  
  return(u32Parity);
}
/*
 ******************************************************************************
 * u8fnCRC8
 ******************************************************************************
 */ 
uint8_t u8fnCRC8(const uint8_t* pu8Buffer, uint8_t u8Poly, uint8_t u8MBitsize, \
                         uint8_t u8Remainder) 
{
  /* Local Variables */
        uint8_t u8Value;
        uint8_t u8ucBit;
        uint8_t u8Count;
        uint8_t u8Polynomial;
  
  u8Polynomial = u8Poly; 
  u8Value      = CLEAR; /* Initial value to make MISRA happy */
                                   
  for (u8Count = CLEAR; u8Count < u8MBitsize; u8Count++)
  {
    /* End of 8 bits process ? */
    if ((u8Count & MSB_MINUS_ONE) == CLEAR) 
    {
      /* get next buffer value   */
      u8Value = pu8Buffer[(u8Count / BITS_IN_BYTE)];
    }
    else
    {
      /* Do nothing */ 
    }
  
    u8ucBit = u8Value ^ u8Remainder;
    u8Remainder = ((uint8_t)(u8Remainder << 1u));
  
    /* MSB CRC bit <> MSB Value bit ? */
    if(u8ucBit & MSB_8_BITS) 
    { 
      u8Remainder ^= u8Polynomial;
    }
    else
    {
      /* Do nothing */
    }
    u8Value = ((uint8_t)(u8Value << 1u));
  }
  
  return(u8Remainder);
}
/*
 ******************************************************************************
 * vfnHexToASCII
 ******************************************************************************
 */
void vfnASCIIByteToHex(uint8_t* pu8Source, uint8_t* pu8Target, 
                       uint16_t u16NOfBytes)
{
  for(; u16NOfBytes > CLEAR; u16NOfBytes--)
  {
    /* Start with the upper nibble */
    *pu8Target = u8fnUnitASCIIToHex(*pu8Source);
    /* Increment Target index */
    pu8Target++;
    pu8Source++;
  }
  
  return;
}
/*
 ******************************************************************************
 * u8fnUnitASCIIToHex
 ******************************************************************************
 */
static uint8_t u8fnUnitASCIIToHex(const uint8_t u8ASCIIData)
{
  uint8_t u8Offset;
  
  u8Offset = CLEAR;
  
  if((u8ASCIIData >= 'A') & (u8ASCIIData <= 'Z'))
  {
    u8Offset = ('A' - (uint8_t)0x0Au);
  }
  else if((u8ASCIIData >= 'a') & (u8ASCIIData <= 'z'))
  {
    u8Offset = ('a' - (uint8_t)0x0Au);
  }
  else if((u8ASCIIData >= '0') & (u8ASCIIData <= '9'))
  {
    u8Offset = '0';
  }
  else
  {
    /* Keep the value as it is */
  }
  
  return(u8ASCIIData - u8Offset);
}
/*
 ******************************************************************************
 * vfnHexToASCIIMaskToList
 ******************************************************************************
 */
void vfnHexToASCIIMaskToList(const uint16_t cu16MaskList,
                             uint8_t* pau8DataArray,
                             uint16_t* pu16Index,
                             const uint16_t cu16Mask)
{
  uint8_t u8Counter;
  
  u8Counter = CLEAR;
  
  for(u8Counter = 1u; u8Counter < 16; u8Counter++)
  {
    if(cu16Mask & (BIT0 << u8Counter))
    {
      break;
    }
    else
    {
      /* loop */
    }
  }
  
  if(cu16MaskList & cu16Mask)
  {
    pau8DataArray[(*pu16Index)++] = u8fnUnitHexToASCII(u8Counter);
    *(pau8DataArray + (*pu16Index)++) = ',';
    *(pau8DataArray + (*pu16Index)++) = ' ';
  }
  else
  {
    /* Nothing */
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnHexToASCII
 ******************************************************************************
 */
void vfnHexToASCII(uint8_t* pu8Source, uint8_t* pu8Target, \
                          uint16_t u16NOfBytes)
{
  for(; u16NOfBytes > CLEAR; u16NOfBytes--)
  {
    /* Start with the upper nibble */
    *pu8Target = u8fnUnitHexToASCII(*pu8Source >> BITS_IN_NIBBLE);
    /* Increment Target index */
    pu8Target++;
    
    /* Continue with the lower nibble */
    *pu8Target = u8fnUnitHexToASCII(*pu8Source & 0x0Fu);
    /* Increment both indeces */
    pu8Target++;
    pu8Source++;
  }
  
  return;
}
/*
 ******************************************************************************
 * u8fnUnitHexToASCII
 ******************************************************************************
 */
static uint8_t u8fnUnitHexToASCII(uint8_t u8HexData)
{
  /* Declare local variables */
  uint8_t u8ASCII;
  
  /* Init local variables */
  u8ASCII = CLEAR;
  
  /* Only look at lower nibble */
  u8HexData &= 0x0F;
  
  /* Translate */
  if (u8HexData < 0x0A)
  {
    u8ASCII = (uint8_t)(u8HexData + '0');
  }
  else
  {
    u8ASCII = (uint8_t)((u8HexData - 0x0Au) + 'A');
  }
  
  return (u8ASCII);
}
/*
 ******************************************************************************
 * vfnCopyArray
 ******************************************************************************
 */
void vfnCopyArray(uint8_t* pu8Source, uint8_t* pu8Target, \
                          uint16_t u16NOfBytes)
{
  for(; u16NOfBytes > CLEAR; u16NOfBytes--)
  {
    /* Start with the upper nibble */
    *pu8Target = *pu8Source;
    /* Increment Target index + Source */
    pu8Target++;
    pu8Source++;
  }
  
  return;
}
/*
 ******************************************************************************
 * Function:          u16fnMaxU16DeltaInArray
 *****************************************************************************/
uint16_t u16fnMaxU16DeltaInArray(const uint16_t* au16Array, uint8_t u8ArraySize)
{
  /* Declare Local Variables */
  uint16_t u16Max;
  uint16_t u16Min;
  
  /* Init local variables */
  u16Max = CLEAR;
  u16Min = USHRT_MAX;
  
  /* Loop from last location to the second one (ignores the first one) */
  for(--u8ArraySize; u8ArraySize != UCHAR_MAX; u8ArraySize--)
  {
    /* Search for Array Max */
    if(u16Max < au16Array[u8ArraySize])
    {
      u16Max = au16Array[u8ArraySize];
    }
    else
    {
      /* Do nothing */
    }
    
    /* Search for Array Min */
    if(u16Min > au16Array[u8ArraySize])
    {
      u16Min = au16Array[u8ArraySize];
    }
    else
    {
      /* Do nothing */
    }
  }/* End for loop */
    
  /* Find Max Delta and return it */
  return (u16Max - u16Min);
}
/*
 ******************************************************************************
 * Function:          u32fnDiffAbsoluteValue
 *****************************************************************************/
uint32_t u32fnDiffAbsoluteValue(uint32_t au32Value1, uint32_t au32Value2)
{
  /* Declare Local Variables */
  uint32_t u32Result;
  
  if(au32Value1 > au32Value2)
  {
    u32Result = au32Value1 - au32Value2;
  }
  else
  {
    u32Result = au32Value2 - au32Value1;
  }
    
  /* Return Absolute Value of the difference */
  return (u32Result);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */